package cn.tedu.csmall.product.service.impl;

import cn.tedu.csmall.product.ex.ServiceException;
import cn.tedu.csmall.product.mapper.CategoryMapper;
import cn.tedu.csmall.product.pojo.dto.CategoryAddNewDTO;
import cn.tedu.csmall.product.pojo.entity.Category;
import cn.tedu.csmall.product.pojo.vo.CategoryListItemVO;
import cn.tedu.csmall.product.pojo.vo.CategoryStandardVO;
import cn.tedu.csmall.product.service.ICategoryService;
import cn.tedu.csmall.product.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 处理类别业务实现类
 *
 * @author liuweitao
 * @version 1.0.0
 */
@Service
@Slf4j
public class CategoryServiceImpl implements ICategoryService {
    @Autowired
    private CategoryMapper categoryMapper;

    //检查：
    // 是否有相同的类别名称;
    // 如果父级id为0，则无法检查父级类别；
    //
    // 任何类别的添加，is_parent状态一定为0;
    // 最后检查：根据父级id检查父级类别的is_parent状态是否是1，如为1则不变，不为1则改为0;
    //
    @Override
    public void addNew(CategoryAddNewDTO categoryAddNewDTO) {
        log.debug("开始处理添加类别的业务，参数：{}",categoryAddNewDTO);
        String name = categoryAddNewDTO.getName();
        int result = categoryMapper.countByName(name);
        if (result != 0){
            String message = "添加类别失败，名称已存在，请更换其它的名称";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT,message);
        }

        //depth默认值为1
        int depth = 1;
        //声明parentCategory
        CategoryStandardVO parentCategory = null;
        //is_parent默认值为0
        int isParent = 0;
        //获取parentId的值
        Long parentId = categoryAddNewDTO.getParentId();
        //开始设置depth值
        if(parentId != 0){
            parentCategory = categoryMapper.getStandardById(parentId);
            if(parentCategory == null){
                String message = "添加类别失败，父类不存在，请输入正确的父类id";
                log.warn(message);
                throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
            }
            depth += parentCategory.getDepth();
        }

        Category category = new Category();
        BeanUtils.copyProperties(categoryAddNewDTO,category);
        category.setDepth(depth).setIsParent(isParent);
        int rows = categoryMapper.insert(category);
        if(rows != 1){
            String message = "添加类别失败，服务器忙，请稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_INSERT,message);
        }

        //开始更新父类的isParent的值
        //方案1：检查是否一级父类，检查父类的isParent值是否为1，设置父类的isParent值为1;
        //方案2：直接设置父类的isParent值为1;
        if(parentId != 0){
            if(parentCategory.getIsParent() != 1){
                Category updateCategory = new Category();
                updateCategory.setId(parentCategory.getId()).setIsParent(1);
                rows = categoryMapper.updateById(updateCategory);
                if(rows != 1){
                    String message = "添加类别失败，服务器忙，请稍后再试";
                    log.warn(message);
                    throw new ServiceException(ServiceCode.ERR_INSERT,message);
                }
            }
        }

        log.debug("添加类别成功");
    }

    @Override
    public void delete(Long id) {
        log.debug("开始处理删除类别的业务，参数：{}",id);
        CategoryStandardVO categoryStandardVO = categoryMapper.getStandardById(id);
        if (categoryStandardVO == null) {
            String message = "删除类别失败，数据不存在，请更换其它的id";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND,message);
        }

        //检查是否为父级类别
        int isParent = categoryStandardVO.getIsParent();
        if(isParent != 0){
            String message = "删除类别失败，服务器忙，稍后再试";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_DELETE,message);
        }

        // 查询父级的子级个数
        Long parentId = categoryStandardVO.getParentId();
        int countChild = categoryMapper.countByParentId(parentId);

        //获取父级
        CategoryStandardVO parentCategory = categoryMapper.getStandardById(parentId);
        // 修改父级的isParent状态
        //确定删除的类别是否有父级和是否是一级父级
        if(parentCategory != null){
            log.debug("查询的父级数据为：{}",parentCategory);
            //确定删除的类别的父级是否还有子级
            if(countChild == 1){
                Category category = new Category();
                category.setIsParent(0).setId(parentCategory.getId());
                categoryMapper.updateById(category);
                log.debug("修改父级的【isParent】状态成功");
            }
        }

        //删除数据
        categoryMapper.deleteById(id);
        log.debug("删除类别成功");
    }

    @Override
    public List<CategoryListItemVO> getListByParentId(Long parentId) {
        log.debug("开始处理根据【parentId】查询类别列表的业务，参数parentId：{}",parentId);
        List<CategoryListItemVO> list = categoryMapper.getListByParentId(parentId);
        log.debug("查询类别列表成功，结果个数：{}",list.size());
        return list;
    }

    @Override
    public List<CategoryListItemVO> getListOnlyParent() {
        log.debug("开始处理查询一级类别列表的业务");
        List<CategoryListItemVO> list = categoryMapper.getListOnlyParent();
        log.debug("查询类别列表成功，结果个数：{}",list.size());
        return list;
    }
}
